package com.ourteam.product.model.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 IRKT 2017
 * Auto Generate Date : 2017-11-17 11:01:07
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductDatabaseDAOQueryBean extends BaseQueryBean {
    public ProductDatabaseDAOQueryBean() {
        super();
    }

    public ProductDatabaseDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductDatabaseDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.Id, "id");
        }
    }

    public void addDatabaseNameSelectProperty() {
        addDatabaseNameSelectProperty("databaseName");
    }

    public void addDatabaseNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabaseName, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabaseName, "databaseName");
        }
    }

    public void addDatabaseTypeSelectProperty() {
        addDatabaseTypeSelectProperty("databaseType");
    }

    public void addDatabaseTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabaseType, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabaseType, "databaseType");
        }
    }

    public void addDatabaseUserSelectProperty() {
        addDatabaseUserSelectProperty("databaseUser");
    }

    public void addDatabaseUserSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabaseUser, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabaseUser, "databaseUser");
        }
    }

    public void addDatabasePasswordSelectProperty() {
        addDatabasePasswordSelectProperty("databasePassword");
    }

    public void addDatabasePasswordSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabasePassword, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabasePassword,
                "databasePassword");
        }
    }

    public void addDatabaseIpSelectProperty() {
        addDatabaseIpSelectProperty("databaseIp");
    }

    public void addDatabaseIpSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabaseIp, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabaseIp, "databaseIp");
        }
    }

    public void addDatabasePortSelectProperty() {
        addDatabasePortSelectProperty("databasePort");
    }

    public void addDatabasePortSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabasePort, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabasePort, "databasePort");
        }
    }

    public void addDatabaseServiceIdSelectProperty() {
        addDatabaseServiceIdSelectProperty("databaseServiceId");
    }

    public void addDatabaseServiceIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.DatabaseServiceId, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.DatabaseServiceId,
                "databaseServiceId");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.Status, "status");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductDatabaseDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductDatabaseDAO.Remarks, "remarks");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addDatabaseNameSelectProperty();

        addDatabaseTypeSelectProperty();

        addDatabaseUserSelectProperty();

        addDatabasePasswordSelectProperty();

        addDatabaseIpSelectProperty();

        addDatabasePortSelectProperty();

        addDatabaseServiceIdSelectProperty();

        addStatusSelectProperty();

        addRemarksSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductDatabaseDAOQueryBean> {
        protected Criteria(ProductDatabaseDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductDatabaseDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductDatabaseDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.Id + " is not null AND " +
                IProductDatabaseDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.Id + " is null OR " +
                IProductDatabaseDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " is null OR " +
                IProductDatabaseDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductDatabaseDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.Id + " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Id + " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductDatabaseDAO.Id + " between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductDatabaseDAO.Id + " between", value1, value2,
                "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductDatabaseDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductDatabaseDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andDatabaseNameIsNull() {
            addCriterion(IProductDatabaseDAO.DatabaseName + " is null");

            return this;
        }

        public Criteria andDatabaseNameIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabaseName + " is not null");

            return this;
        }

        public Criteria andDatabaseNameIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabaseName +
                " is not null AND " + IProductDatabaseDAO.DatabaseName +
                " <> ''");

            return this;
        }

        public Criteria andDatabaseNameIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabaseName +
                " is null OR " + IProductDatabaseDAO.DatabaseName + " = '')");

            return this;
        }

        public Criteria andDatabaseNameEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " = ", value,
                "databaseName");

            return this;
        }

        public Criteria andDatabaseNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " <>", value,
                "databaseName");

            return this;
        }

        public Criteria andDatabaseNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " is null OR " +
                IProductDatabaseDAO.DatabaseName + " <>", value, "databaseName");

            return this;
        }

        public Criteria andDatabaseNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " >", value,
                "databaseName");

            return this;
        }

        public Criteria andDatabaseNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " >=", value,
                "databaseName");

            return this;
        }

        public Criteria andDatabaseNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " <", value,
                "databaseName");

            return this;
        }

        public Criteria andDatabaseNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " <=", value,
                "databaseName");

            return this;
        }

        public Criteria andDatabaseNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseName + " like",
                buffer.toString(), "databaseName");

            return this;
        }

        public Criteria andDatabaseNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseName + " not like",
                buffer.toString(), "databaseName");

            return this;
        }

        public Criteria andDatabaseNameIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseName + " in", values,
                    "databaseName");

                return this;
            }
        }

        public Criteria andDatabaseNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseName + " not in",
                    values, "databaseName");

                return this;
            }
        }

        public Criteria andDatabaseNameIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseNameEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseName + " in",
                    Arrays.asList(values), "databaseName");

                return this;
            }
        }

        public Criteria andDatabaseNameNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseName + " not in",
                    Arrays.asList(values), "databaseName");

                return this;
            }
        }

        public Criteria andDatabaseNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseNameBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " between", value1,
                value2, "databaseName");

            return this;
        }

        public Criteria andDatabaseNameNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseName + " not between",
                value1, value2, "databaseName");

            return this;
        }

        public Criteria andDatabaseTypeIsNull() {
            addCriterion(IProductDatabaseDAO.DatabaseType + " is null");

            return this;
        }

        public Criteria andDatabaseTypeIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabaseType + " is not null");

            return this;
        }

        public Criteria andDatabaseTypeIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabaseType +
                " is not null AND " + IProductDatabaseDAO.DatabaseType +
                " <> ''");

            return this;
        }

        public Criteria andDatabaseTypeIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabaseType +
                " is null OR " + IProductDatabaseDAO.DatabaseType + " = '')");

            return this;
        }

        public Criteria andDatabaseTypeEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " = ", value,
                "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseTypeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " <>", value,
                "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " is null OR " +
                IProductDatabaseDAO.DatabaseType + " <>", value, "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseTypeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " >", value,
                "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseTypeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " >=", value,
                "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " <", value,
                "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseTypeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " <=", value,
                "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseType + " like",
                buffer.toString(), "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseType + " not like",
                buffer.toString(), "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseType + " in", values,
                    "databaseType");

                return this;
            }
        }

        public Criteria andDatabaseTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseType + " not in",
                    values, "databaseType");

                return this;
            }
        }

        public Criteria andDatabaseTypeIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseType + " in",
                    Arrays.asList(values), "databaseType");

                return this;
            }
        }

        public Criteria andDatabaseTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseType + " not in",
                    Arrays.asList(values), "databaseType");

                return this;
            }
        }

        public Criteria andDatabaseTypeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseTypeBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " between", value1,
                value2, "databaseType");

            return this;
        }

        public Criteria andDatabaseTypeNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseType + " not between",
                value1, value2, "databaseType");

            return this;
        }

        public Criteria andDatabaseUserIsNull() {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " is null");

            return this;
        }

        public Criteria andDatabaseUserIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " is not null");

            return this;
        }

        public Criteria andDatabaseUserIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabaseUser +
                " is not null AND " + IProductDatabaseDAO.DatabaseUser +
                " <> ''");

            return this;
        }

        public Criteria andDatabaseUserIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabaseUser +
                " is null OR " + IProductDatabaseDAO.DatabaseUser + " = '')");

            return this;
        }

        public Criteria andDatabaseUserEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " = ", value,
                "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseUser);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseUserEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " <>", value,
                "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " is null OR " +
                IProductDatabaseDAO.DatabaseUser + " <>", value, "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseUser);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseUserNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " >", value,
                "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseUser);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseUserGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " >=", value,
                "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseUser);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseUserGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " <", value,
                "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseUser);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseUserLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " <=", value,
                "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseUser);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseUserLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseUser + " like",
                buffer.toString(), "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseUser + " not like",
                buffer.toString(), "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseUserEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseUser + " in", values,
                    "databaseUser");

                return this;
            }
        }

        public Criteria andDatabaseUserNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseUserNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseUser + " not in",
                    values, "databaseUser");

                return this;
            }
        }

        public Criteria andDatabaseUserIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseUserEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseUser + " in",
                    Arrays.asList(values), "databaseUser");

                return this;
            }
        }

        public Criteria andDatabaseUserNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseUserNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseUser + " not in",
                    Arrays.asList(values), "databaseUser");

                return this;
            }
        }

        public Criteria andDatabaseUserIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseUserBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " between", value1,
                value2, "databaseUser");

            return this;
        }

        public Criteria andDatabaseUserNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseUser + " not between",
                value1, value2, "databaseUser");

            return this;
        }

        public Criteria andDatabasePasswordIsNull() {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " is null");

            return this;
        }

        public Criteria andDatabasePasswordIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " is not null");

            return this;
        }

        public Criteria andDatabasePasswordIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabasePassword +
                " is not null AND " + IProductDatabaseDAO.DatabasePassword +
                " <> ''");

            return this;
        }

        public Criteria andDatabasePasswordIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabasePassword +
                " is null OR " + IProductDatabaseDAO.DatabasePassword +
                " = '')");

            return this;
        }

        public Criteria andDatabasePasswordEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " = ", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePassword);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePasswordEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " <>", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " is null OR " +
                IProductDatabaseDAO.DatabasePassword + " <>", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePassword);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePasswordNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " >", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePassword);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePasswordGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " >=", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePassword);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePasswordGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " <", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePassword);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePasswordLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " <=", value,
                "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePassword);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePasswordLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabasePassword + " like",
                buffer.toString(), "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabasePassword + " not like",
                buffer.toString(), "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabasePasswordEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePassword + " in",
                    values, "databasePassword");

                return this;
            }
        }

        public Criteria andDatabasePasswordNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabasePasswordNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePassword + " not in",
                    values, "databasePassword");

                return this;
            }
        }

        public Criteria andDatabasePasswordIn(String[] values) {
            if (values.length == 1) {
                return andDatabasePasswordEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePassword + " in",
                    Arrays.asList(values), "databasePassword");

                return this;
            }
        }

        public Criteria andDatabasePasswordNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabasePasswordNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePassword + " not in",
                    Arrays.asList(values), "databasePassword");

                return this;
            }
        }

        public Criteria andDatabasePasswordIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePasswordBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " between",
                value1, value2, "databasePassword");

            return this;
        }

        public Criteria andDatabasePasswordNotBetween(String value1,
            String value2) {
            addCriterion(IProductDatabaseDAO.DatabasePassword + " not between",
                value1, value2, "databasePassword");

            return this;
        }

        public Criteria andDatabaseIpIsNull() {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " is null");

            return this;
        }

        public Criteria andDatabaseIpIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " is not null");

            return this;
        }

        public Criteria andDatabaseIpIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " is not null AND " +
                IProductDatabaseDAO.DatabaseIp + " <> ''");

            return this;
        }

        public Criteria andDatabaseIpIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabaseIp + " is null OR " +
                IProductDatabaseDAO.DatabaseIp + " = '')");

            return this;
        }

        public Criteria andDatabaseIpEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " = ", value,
                "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseIp);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseIpEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " <>", value,
                "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " is null OR " +
                IProductDatabaseDAO.DatabaseIp + " <>", value, "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseIp);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseIpNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " >", value,
                "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseIp);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseIpGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " >=", value,
                "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseIp);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseIpGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " <", value,
                "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseIp);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseIpLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " <=", value,
                "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseIp);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseIpLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseIp + " like",
                buffer.toString(), "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseIp + " not like",
                buffer.toString(), "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseIpEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseIp + " in", values,
                    "databaseIp");

                return this;
            }
        }

        public Criteria andDatabaseIpNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseIpNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseIp + " not in",
                    values, "databaseIp");

                return this;
            }
        }

        public Criteria andDatabaseIpIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseIpEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseIp + " in",
                    Arrays.asList(values), "databaseIp");

                return this;
            }
        }

        public Criteria andDatabaseIpNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseIpNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseIp + " not in",
                    Arrays.asList(values), "databaseIp");

                return this;
            }
        }

        public Criteria andDatabaseIpIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andDatabaseIpNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseIpBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " between", value1,
                value2, "databaseIp");

            return this;
        }

        public Criteria andDatabaseIpNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseIp + " not between",
                value1, value2, "databaseIp");

            return this;
        }

        public Criteria andDatabasePortIsNull() {
            addCriterion(IProductDatabaseDAO.DatabasePort + " is null");

            return this;
        }

        public Criteria andDatabasePortIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabasePort + " is not null");

            return this;
        }

        public Criteria andDatabasePortIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabasePort +
                " is not null AND " + IProductDatabaseDAO.DatabasePort +
                " <> ''");

            return this;
        }

        public Criteria andDatabasePortIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabasePort +
                " is null OR " + IProductDatabaseDAO.DatabasePort + " = '')");

            return this;
        }

        public Criteria andDatabasePortEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " = ", value,
                "databasePort");

            return this;
        }

        public Criteria andDatabasePortEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePort);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePortEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " <>", value,
                "databasePort");

            return this;
        }

        public Criteria andDatabasePortNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " is null OR " +
                IProductDatabaseDAO.DatabasePort + " <>", value, "databasePort");

            return this;
        }

        public Criteria andDatabasePortNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePort);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePortNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " >", value,
                "databasePort");

            return this;
        }

        public Criteria andDatabasePortGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePort);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePortGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " >=", value,
                "databasePort");

            return this;
        }

        public Criteria andDatabasePortGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePort);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePortGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " <", value,
                "databasePort");

            return this;
        }

        public Criteria andDatabasePortLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePort);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePortLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " <=", value,
                "databasePort");

            return this;
        }

        public Criteria andDatabasePortLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabasePort);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabasePortLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabasePort + " like",
                buffer.toString(), "databasePort");

            return this;
        }

        public Criteria andDatabasePortNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabasePort + " not like",
                buffer.toString(), "databasePort");

            return this;
        }

        public Criteria andDatabasePortIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabasePortEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePort + " in", values,
                    "databasePort");

                return this;
            }
        }

        public Criteria andDatabasePortNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabasePortNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePort + " not in",
                    values, "databasePort");

                return this;
            }
        }

        public Criteria andDatabasePortIn(String[] values) {
            if (values.length == 1) {
                return andDatabasePortEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePort + " in",
                    Arrays.asList(values), "databasePort");

                return this;
            }
        }

        public Criteria andDatabasePortNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabasePortNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabasePort + " not in",
                    Arrays.asList(values), "databasePort");

                return this;
            }
        }

        public Criteria andDatabasePortIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabasePortBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " between", value1,
                value2, "databasePort");

            return this;
        }

        public Criteria andDatabasePortNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabasePort + " not between",
                value1, value2, "databasePort");

            return this;
        }

        public Criteria andDatabaseServiceIdIsNull() {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " is null");

            return this;
        }

        public Criteria andDatabaseServiceIdIsNotNull() {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId +
                " is not null");

            return this;
        }

        public Criteria andDatabaseServiceIdIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId +
                " is not null AND " + IProductDatabaseDAO.DatabaseServiceId +
                " <> ''");

            return this;
        }

        public Criteria andDatabaseServiceIdIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.DatabaseServiceId +
                " is null OR " + IProductDatabaseDAO.DatabaseServiceId +
                " = '')");

            return this;
        }

        public Criteria andDatabaseServiceIdEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " = ", value,
                "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseServiceId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseServiceIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " <>", value,
                "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId +
                " is null OR " + IProductDatabaseDAO.DatabaseServiceId + " <>",
                value, "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseServiceId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseServiceIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " >", value,
                "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseServiceId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseServiceIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " >=", value,
                "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseServiceId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseServiceIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdLessThan(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " <", value,
                "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseServiceId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseServiceIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " <=", value,
                "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.DatabaseServiceId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDatabaseServiceIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " like",
                buffer.toString(), "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " not like",
                buffer.toString(), "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseServiceIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseServiceId + " in",
                    values, "databaseServiceId");

                return this;
            }
        }

        public Criteria andDatabaseServiceIdNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDatabaseServiceIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseServiceId + " not in",
                    values, "databaseServiceId");

                return this;
            }
        }

        public Criteria andDatabaseServiceIdIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseServiceIdEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseServiceId + " in",
                    Arrays.asList(values), "databaseServiceId");

                return this;
            }
        }

        public Criteria andDatabaseServiceIdNotIn(String[] values) {
            if (values.length == 1) {
                return andDatabaseServiceIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.DatabaseServiceId + " not in",
                    Arrays.asList(values), "databaseServiceId");

                return this;
            }
        }

        public Criteria andDatabaseServiceIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDatabaseServiceIdBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId + " between",
                value1, value2, "databaseServiceId");

            return this;
        }

        public Criteria andDatabaseServiceIdNotBetween(String value1,
            String value2) {
            addCriterion(IProductDatabaseDAO.DatabaseServiceId +
                " not between", value1, value2, "databaseServiceId");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductDatabaseDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductDatabaseDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.Status + " is not null AND " +
                IProductDatabaseDAO.Status + " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.Status + " is null OR " +
                IProductDatabaseDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Status + " = ", value, "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.Status + " is null OR " +
                IProductDatabaseDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.Status + " >", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Status + " >=", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductDatabaseDAO.Status + " <", value, "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Status + " <=", value, "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.Status + " in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.Status + " not in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Status + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.Status + " between", value1,
                value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.Status + " not between", value1,
                value2, "status");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductDatabaseDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductDatabaseDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductDatabaseDAO.Remarks + " is not null AND " +
                IProductDatabaseDAO.Remarks + " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductDatabaseDAO.Remarks + " is null OR " +
                IProductDatabaseDAO.Remarks + " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " = ", value, "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " is null OR " +
                IProductDatabaseDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " >", value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " >=", value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " <", value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductDatabaseDAO.Remarks + " <=", value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductDatabaseDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductDatabaseDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.Remarks + " in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductDatabaseDAO.Remarks + " not in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductDatabaseDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductDatabaseDAO.Remarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.Remarks + " between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductDatabaseDAO.Remarks + " not between", value1,
                value2, "remarks");

            return this;
        }
    }
}
